Project: Create Optimal Hotel Recommendations¶
Author: Robert Zacchigna¶
Table of Contents¶
- Part 1: Exploratory Data Analysis
- Randomly Sample Dataset (75,000 records) and Drop all Missing (NaN) Values
- Merge destination.csv with Sampled train.csv data (on "srch_destination_id" column) and Drop All Missing (NaN) Values
- Move Target variable (hotel_cluster) to the Front of the Dataset
- Balance the Dataset so that the Target Variable has Equal Records for Each Hotel Cluster
- Pandas Profiling Report of the Final Balanced Dataset (Without Destination Columns)
- Part 2: Data Preprocessing and Feature Reduction
- Part 3: Model Evaluation and Selection
- Split Balanced PCA Dataset into Train and Test Sets
- Conduct RandomForest Classifier Modeling
- Create Pipeline for Scaling and Running RandomForest Classification Modeling
- Setup Parameters RandomForest Classification Model to be Tested by GridSearchCV
- Fit Data to RandomForest Grid to Find the Best Parameters for the RandomForest Classification Model
- Display Top Accuracy Scores Found by GridSearchCV
- From the Dataframe Above, Display the Best Params and Score for the RandomForest Classification Model
- Conduct DecisionTree Classification Modeling
- Create Pipeline for Scaling and Running DecisionTree Classification Modeling
- Setup Parameters for DecisionTree Classifier Model to be Tested by GridSearchCV
- Fit Data to DecisionTree Grid to Find the Best Parameters for the DecisionTree Classification Model
- Display Top Accuracy Scores Found by GridSearchCV
- From the Dataframe Above, Display the Best Params and Score for the DecisionTree Classifier Model
- Compare the Accuracy Scores of Each Model
Problem Statement¶
Online travel agencies are scrambling to meet the artificial intelligence driven personalization standard set by companies like Amazon and Netflix. In addition, the world of online travel has become a highly competitive space where brands try to capture our attention (and wallet) with recommending, comparing, matching, and sharing.
Proposal¶
Create optimal hotel recommendations for Expedia's users that are searching for a hotel to book, specifically predict which "hotel cluster" the user is likely to book, given his (or her) search details.
Split train.csv into a training and test set (feel free to select a smaller random subset of train.csv). There is another file named destinations.csv, which contains information related to hotel reviews made by users. Then, build at least two prediction models from the training set, and report the accuracies on the test set.
Dataset - Expedia Hotel Recommendations¶
Download Location: https://www.kaggle.com/c/expedia-hotel-recommendations/data
- date_time – Timestamp
- site_name – ID of the Expedia point of sale (i.e. Expedia.com, Expedia.co.uk, Expedia.co.jp, ...)
- posa_continent – ID of continent associated with site_name
- user_location_country – The ID of the country the customer is located
- user_location_region – The ID of the region the customer is located
- user_location_city – The ID of the city the customer is located
- orig_destination_distance – Physical distance between a hotel and a customer at the time of search. A null means the distance could not be calculated
- user_id – ID of user
- is_mobile – 1 when a user connected from a mobile device, 0 otherwise
- is_package – 1 if the click/booking was generated as a part of a package (i.e. combined with a flight), 0 otherwise
- channel – ID of a marketing channel
- srch_ci – Checkin date
- srch_co – Checkout date
- srch_adults_cnt – The number of adults specified in the hotel room
- srch_children_cnt – The number of (extra occupancy) children specified in the hotel room
- srch_rm_cnt – The number of hotel rooms specified in the search
- srch_destination_id – ID of the destination where the hotel search was performed
- srch_destination_type_id – Type of destination
- hotel_continent – Hotel continent
- hotel_country – Hotel country
- hotel_market – Hotel market
- is_booking – 1 if a booking, 0 if a click
- cnt – Numer of similar events in the context of the same user session
- hotel_cluster – ID of a hotel cluster
- srch_destination_id – ID of the destination where the hotel search was performed
- d1-d149 – latent description of search regions
Imports¶
In [1]:
import random
import numpy as np
import pandas as pd
import seaborn as sb
import datetime as dt
import pandas_profiling as pp
from scipy.stats import norm
from matplotlib import pyplot as plt
from sklearn.decomposition import PCA
from sklearn.pipeline import Pipeline
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, make_scorer
from sklearn.model_selection import train_test_split, GridSearchCV
In [2]:
seed = 42 # set seed
n = sum(1 for line in open(filename)) - 1
s = 75000 # desired sample size
random.seed(seed)
skip = sorted(random.sample(range(1, n + 1), n - s)) # randomly sample dataset
# Read train.csv and drop all missing (NaN) values
hotelData = pd.read_csv('Expedia_Hotel_Data/train.csv', skiprows=skip).dropna().reset_index(drop=True)
In [3]:
print('Dataset shape: {:,} columns and {:,} rows'.format(hotelData.shape[1], hotelData.shape[0]))
In [4]:
hotelData.head()
Out[4]:
Merge destination.csv with Sampled train.csv data (on "srch_destination_id" column) and Drop All Missing (NaN) Values¶
In [6]:
destData = hotelData.merge(pd.read_csv('expedia-hotel-recommendations/destinations.csv'),
how='left', on='srch_destination_id').dropna().reset_index(drop=True)
Move Target variable (hotel_cluster) to the Front of the Dataset¶
In [ ]:
tmp = destData['hotel_cluster']
destData = destData.drop(['hotel_cluster'], axis=1)
destData.insert(0, 'hotel_cluster', tmp)
In [7]:
print('Merged Destination Dataset shape: {:,} columns and {:,} rows'.format(destData.shape[1], destData.shape[0]))
In [8]:
destData.head()
Out[8]:
Balance the Dataset so that the Target Variable has Equal Records for Each Hotel Cluster¶
In [9]:
balData = destData.groupby('hotel_cluster')
balData = pd.DataFrame(balData.apply(lambda x:
x.sample(balData.size().min()).reset_index(drop=True))).droplevel('hotel_cluster').reset_index(drop=True)
In [10]:
print('Merged Balanced Dataset shape: {:,} columns and {:,} rows'.format(balData.shape[1], balData.shape[0]))
In [11]:
balData.head()
Out[11]:
Pandas Profiling Report of the Final Balanced Dataset (Without Destination Columns)¶
In [97]:
pp.ProfileReport(balData[balData.columns[:24]]).to_notebook_iframe()
In [12]:
for col in ['srch_ci', 'srch_co']:
balData[col] = pd.to_datetime(balData[col], format = '%Y-%m-%d')
balData[col] = balData[col].map(dt.datetime.toordinal)
balData['date_time'] = pd.to_datetime(balData['date_time'], format = '%Y-%m-%dT%H:%M:%S')
balData['date_time'] = balData['date_time'].map(dt.datetime.toordinal)
New Data Types for Each of the Datetime Columns¶
In [13]:
for col in ['date_time', 'srch_ci', 'srch_co']:
print('Column: ' + col + ', Type: ' + str(type(balData[col][0])))
In [14]:
balData[['date_time', 'srch_ci', 'srch_co']]
Out[14]:
Use PCA (Principal Component Analysis) to Reduce the Number of Destination Columns in the Dataset¶
I will be using PCA feature reduction technique to reduce the number of columns, specifically the destination columns, in the dataset down to a more manageable amount for training models.
In [15]:
fig = plt.figure()
fig.set_size_inches(15, 12)
sb.set(font_scale = 1.25)
N_COMPONENTS = len(balData.columns[24:])
pca = PCA(n_components = N_COMPONENTS)
pc_matrix = pca.fit_transform(balData[balData.columns[24:]])
evr = pca.explained_variance_ratio_ * 100
cumsum_evr = np.cumsum(evr)
tickMarks = 10
ax = sb.lineplot(x=np.arange(1, len(cumsum_evr) + 1), y=cumsum_evr, label='Explained Variance Ratio')
ax.lines[0].set_linestyle('-.')
ax.set_title('Explained Variance Ratio Using {} Components'.format(N_COMPONENTS))
ax.plot(np.arange(1, len(cumsum_evr) + 1), cumsum_evr, 'bo')
for x, y in zip(range(1, len(cumsum_evr) + 1), cumsum_evr):
if x in np.arange(1, 8, 1) or x % tickMarks == 0:
plt.annotate("{:.2f}%".format(y), (x, y), xytext=(2, -15),
textcoords="offset points", annotation_clip = False)
ax = sb.lineplot(x=np.arange(1, len(cumsum_evr) + 1), y=evr, label='Explained Variance Of Component X')
ax.plot(np.arange(1, len(evr) + 1), evr,'ro')
ax.lines[1].set_linestyle('-.')
ax.set_xticks([i for i in range(1, len(cumsum_evr) + 1) if i in np.arange(1, 2, 1) or i % tickMarks == 0])
for x, y in zip(range(1, len(cumsum_evr) + 1), evr):
if x != 1 and (x in np.arange(1, 5, 1) or x % tickMarks == 0):
plt.annotate("{:.2f}%".format(y), (x, y), xytext=(2, 5),
textcoords="offset points", annotation_clip = False)
ax.set_xlabel('Component Number')
ax.set_ylabel('Explained Variance')
Out[15]:
From the graph above, we can see that of the 149 total components, using only the first 10 will account for almost 81% of the destination column data. As a result, i will be using the first 10 components to explain the destination column data.
Drop Destination Columns from x_train and Append First 10 PCA Components¶
In [16]:
balData = balData[balData.columns[:24]]
bal_PCA_Data = pd.concat([balData,
pd.DataFrame(pc_matrix, columns=['PC-{}'.format(i) for i in range(1, N_COMPONENTS + 1)])], axis=1)
bal_PCA_Data = bal_PCA_Data[bal_PCA_Data.columns[:34]]
In [17]:
print('PCA Balanced Dataset shape: {:,} columns and {:,} rows'.format(bal_PCA_Data.shape[1], bal_PCA_Data.shape[0]))
In [18]:
bal_PCA_Data.head()
Out[18]:
In [19]:
bal_PCA_Data.describe()
Out[19]:
Annotated Correlation Matrix of Balanced Data with PCA Components¶
In [20]:
fig = plt.figure()
fig.set_size_inches(20, 15)
sb.set(font_scale = 0.8)
sb.heatmap(bal_PCA_Data.corr('pearson'), annot=True)
Out[20]:
Part 3: Model Evaluation and Selection¶
The models I have selected to experiment with in this analysis are the following: Random Forest Classifier and Decision Tree Classifier. The models performances (accuracy Score) with the training data will be compared at the end to see which model performed the best and then the best model will be used as the final model for predicting on the test set.
Split Balanced PCA Dataset into Train and Test Sets¶
In [21]:
x_train, x_test, y_train, y_test = train_test_split(bal_PCA_Data[bal_PCA_Data.columns[1:]],
bal_PCA_Data['hotel_cluster'],
train_size=0.65,
random_state=seed)
X_Train Set¶
In [22]:
print('x_train shape: {:,} columns and {:,} rows'.format(x_train.shape[1], x_train.shape[0]))
In [23]:
x_train.head()
Out[23]:
In [24]:
x_train.describe()
Out[24]:
Y_Train Set¶
In [25]:
print('y_train shape: 1 column and {:,} rows'.format(y_train.shape[0]))
In [26]:
y_train.head()
Out[26]:
In [27]:
y_train.describe()
Out[27]:
In [28]:
rf_pipe = Pipeline(steps=([
('scale', StandardScaler()),
('rf', RandomForestClassifier(random_state=seed))
]))
Setup Parameters RandomForest Classification Model to be Tested by GridSearchCV¶
In [29]:
param_grid = {'rf__max_depth': [2, 4, 6],
'rf__class_weight': ['balanced', 'balanced_subsample'],
'rf__criterion': ['gini', 'entropy'],
'rf__max_features': ['auto', 'sqrt', 'log2'],
'rf__min_samples_leaf': [2, 3],
'rf__min_samples_split': [2, 3],
'rf__n_estimators': [100, 200]}
rf_grid = GridSearchCV(rf_pipe, scoring=make_scorer(accuracy_score),
param_grid = param_grid, cv = 5, n_jobs = -1, verbose=2)
Fit Data to RandomForest Grid to Find the Best Parameters for the RandomForest Classification Model¶
In [30]:
rf_grid.fit(x_train, y_train)
Out[30]:
Display Top Accuracy Scores Found by GridSearchCV¶
In [31]:
rf_df = pd.DataFrame(rf_grid.cv_results_).sort_values('mean_test_score',
ascending=False)[['params', 'mean_test_score']].head(10)
rf_df
Out[31]:
From the Dataframe Above, Display the Best Params and Score for the RandomForest Classification Model¶
In [33]:
print('Best Random Forest Classification Parameters\n' + '='*44)
for name, val in rf_df.iloc[0]['params'].items():
print('{:>24}: {}'.format(name.replace('rf__', ''), val))
rf_acc = rf_df.iloc[0]['mean_test_score']
print('\nAccuracy Score: {}'.format(round(rf_acc, 4)))
In [40]:
dt_pipe = Pipeline(steps=([
('scale', StandardScaler()),
('dt', DecisionTreeClassifier(random_state=seed))
]))
Setup Parameters for DecisionTree Classifier Model to be Tested by GridSearchCV¶
In [48]:
param_grid = {'dt__criterion': ['gini', 'entropy'],
'dt__class_weight': ['balanced', None],
'dt__splitter': ['best', 'random'],
'dt__max_features': ['auto', 'sqrt', 'log2'],
'dt__max_depth': [2, 4, 6],
'dt__min_samples_leaf': [1, 2, 4],
'dt__min_samples_split': [2, 4, 6]}
dt_grid = GridSearchCV(dt_pipe, scoring=make_scorer(accuracy_score),
param_grid = param_grid, cv = 5, n_jobs = -1, verbose=2)
Fit Data to DecisionTree Grid to Find the Best Parameters for the DecisionTree Classification Model¶
In [49]:
dt_grid.fit(x_train, y_train)
Out[49]:
Display Top Accuracy Scores Found by GridSearchCV¶
In [50]:
dt_df = pd.DataFrame(dt_grid.cv_results_).sort_values('mean_test_score',
ascending=False)[['params', 'mean_test_score']].head(10)
dt_df
Out[50]:
From the Dataframe Above, Display the Best Params and Score for the DecisionTree Classifier Model¶
In [51]:
print('Best Decision Tree Classification Parameters\n' + '='*44)
for name, val in dt_df.iloc[0]['params'].items():
print('{:>23}: {}'.format(name.replace('dt__', ''), val))
dt_acc = dt_df.iloc[0]['mean_test_score']
print('\nAccuracy Score: {}'.format(round(dt_acc, 4)))
In [52]:
acc_scores = [rf_acc, dt_acc]
modelTypes = ['Random Forest Classifier', 'Decision Tree Classifier']
acc_df = pd.DataFrame(zip(modelTypes, acc_scores), columns=['Model Type', 'Accuracy Score'])
acc_df = acc_df.nlargest(len(acc_df), 'Accuracy Score').reset_index(drop=True)
acc_df
Out[52]:
From the above table we can see both models did not have very good accuracy but the Random Forest Classifier did perform the best so that will be the model that i will use to make predictions on the test set for final analysis and results.
Part 4: Final Model and Analysis Results¶
Construct Final Model - Random Forest Classifier¶
Display Best Parameters Found by GridSearchCV for the RandomForest Classifier Model¶
In [72]:
print('Best Random Forest Classifier Parameters\n' + '='*40)
params = {}
for name, val in rf_df.iloc[0]['params'].items():
name = name.replace('rf__', '')
params.update({name: val})
print('{:>21}: {}'.format(name, val))
rf_acc = rf_df.iloc[0]['mean_test_score']
print('\nAccuracy Score: {}'.format(round(rf_acc, 4)))
Create Pipeline for Scaling and Running the Best RandomForest Classifier Model¶
In [73]:
best_pipe = Pipeline(steps=([
('scale', StandardScaler()),
('rf', RandomForestClassifier(**params, random_state=seed))
]))
Fit the Model to the Entire Training Dataset¶
In [74]:
best_model = best_pipe.fit(x_train, y_train)
best_model
Out[74]:
Use RandomForest Classifier Model to Predict the Hotel Clusters on Test Dataset¶
In [75]:
y_pred = best_model.predict(x_test)
Compare Accuracy Scores of Train Model and Best Model (with Test Data)¶
In [76]:
best_model_score = accuracy_score(y_test, y_pred)
print("Best Random Forest Classifier score using the test data\n" + '='*50 +
"\nTest Accuracy Score: {}\n\nTrain Accuracy Score: {}".format(round(best_model_score, 4), round(rf_acc, 4)))
print('\nDifference between train and best model test accuracy scores: {}'
.format(abs(round(best_model_score - rf_acc, 4))))
Since the accuracy scores is so close to the value i received during my training experiments, i am confident the model i have selected will perform well with future, unseen, customer hotel data.
Use RandomForest Classifier Model to Predict Hotel Clusters on the Whole Sampled Dataset¶
In [88]:
orginData_PCA_Pred = best_model.predict(bal_PCA_Data[bal_PCA_Data.columns[1:]])
print("Best Random Forest Classifier score using the Whole Sampled Dataset\n" + '='*67 +
"\nAccuracy Score: {}".format(round(accuracy_score(bal_PCA_Data['hotel_cluster'], orginData_PCA_Pred), 4)))
Analysis Conclusion¶
The accuracy score for predicting on the entirety of the sampled dataset is roughly double what i got during experimentation, most likely due to the increase in dataset size. The score is still quite bad and would most likely improve with a larger sample size and a different tuned model (and a stronger computer to train the model). I had originally decided to use XGBoost but the model training was taking far too long than what was feasible for me (even with the small sample size) and thus was forced to change to a different model.
In [ ]: